{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "initial_id",
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "'''\n",
    "CountVectorizer是属于常见的特征数值计算类，是一个文本特征提取方法。对于每一个训练文本，它只考虑每种词汇在该训练文本中出现的频率。\n",
    "\n",
    "CountVectorizer会将文本中的词语转换为词频矩阵，它通过fit_transform函数计算各个词语出现的频率，并将结果存储在一个稀疏矩阵中。\n",
    "原文链接：https://blog.csdn.net/weixin_38278334/article/details/82320307\n",
    "\n",
    "CountVectorizer是通过fit_transform函数将文本中的词语转换为词频矩阵，矩阵元素a[i][j] 表示j词在第i个文本下的词频。即各个词语出现的次数，通过get_feature_names()可看到所有文本的关键字，通过toarray()可看到词频矩阵的结果。\n",
    "'''"
   ]
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-09T12:00:07.292733Z",
     "start_time": "2025-01-09T12:00:07.190835Z"
    }
   },
   "cell_type": "code",
   "source": [
    "from sklearn.feature_extraction import DictVectorizer\n",
    "from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer\n",
    "from sklearn.preprocessing import MinMaxScaler, StandardScaler\n",
    "from sklearn.feature_selection import VarianceThreshold\n",
    "from sklearn.decomposition import PCA\n",
    "import jieba\n",
    "import numpy as np\n",
    "from sklearn.impute import SimpleImputer"
   ],
   "id": "25fc5c63c04cdb04",
   "outputs": [],
   "execution_count": 13
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-09T11:47:37.827220Z",
     "start_time": "2025-01-09T11:47:37.821229Z"
    }
   },
   "cell_type": "code",
   "source": [
    "def couvec():\n",
    "    # 实例化CountVectorizer\n",
    "    # max_df, min_df整数：指每个词的所有文档词频数不小于最小值，出现该词的文档数目小于等于max_df\n",
    "    # max_df, min_df小数(0-1之间的）：某个词的出现的次数／所有文档数量\n",
    "    # min_df=2\n",
    "    # 默认会去除单个字母的单词，默认认为这个词对整个样本没有影响,认为其没有语义\n",
    "    vector = CountVectorizer(min_df=2)\n",
    "\n",
    "    # 调用fit_transform输入并转换数据\n",
    "\n",
    "    res = vector.fit_transform(\n",
    "        [\"life is  short,i like python life\",\n",
    "         \"life is too long,i dislike python\",\n",
    "         \"life is short\"])\n",
    "\n",
    "    # 打印结果,把每个词都分离了\n",
    "    print(vector.get_feature_names_out())\n",
    "    print('-'*50)\n",
    "    print(res)\n",
    "    print('-'*50)\n",
    "    print(type(res))\n",
    "    # 对照feature_names，标记每个词出现的次数\n",
    "    print('-'*50)\n",
    "    print(res.toarray()) #稀疏矩阵转换为数组\n",
    "    print('-'*50)\n",
    "    #拿每个样本里的特征进行显示\n",
    "    print(vector.inverse_transform(res))\n",
    "\n",
    "\n",
    "couvec()"
   ],
   "id": "b8de523c5c5ec28d",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['is' 'life' 'python' 'short']\n",
      "--------------------------------------------------\n",
      "<Compressed Sparse Row sparse matrix of dtype 'int64'\n",
      "\twith 10 stored elements and shape (3, 4)>\n",
      "  Coords\tValues\n",
      "  (0, 1)\t2\n",
      "  (0, 0)\t1\n",
      "  (0, 3)\t1\n",
      "  (0, 2)\t1\n",
      "  (1, 1)\t1\n",
      "  (1, 0)\t1\n",
      "  (1, 2)\t1\n",
      "  (2, 1)\t1\n",
      "  (2, 0)\t1\n",
      "  (2, 3)\t1\n",
      "--------------------------------------------------\n",
      "<class 'scipy.sparse._csr.csr_matrix'>\n",
      "--------------------------------------------------\n",
      "[[1 2 1 1]\n",
      " [1 1 1 0]\n",
      " [1 1 0 1]]\n",
      "--------------------------------------------------\n",
      "[array(['life', 'is', 'short', 'python'], dtype='<U6'), array(['life', 'is', 'python'], dtype='<U6'), array(['life', 'is', 'short'], dtype='<U6')]\n"
     ]
    }
   ],
   "execution_count": 2
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-09T11:48:02.810036Z",
     "start_time": "2025-01-09T11:48:02.804660Z"
    }
   },
   "cell_type": "code",
   "source": [
    "def countvec():\n",
    "    \"\"\"\n",
    "    对文本进行特征值化,单个汉字单个字母不统计，因为单个汉字字母没有意义\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    cv = CountVectorizer() \n",
    "\n",
    "    data = cv.fit_transform([\"人生苦短，我 喜欢 python python\", \"人生漫长，不用 python\"])\n",
    "\n",
    "    print(cv.get_feature_names_out())\n",
    "    print('-'*50)\n",
    "    print(data) #稀疏存储，只记录非零位置\n",
    "    print('-'*50)\n",
    "    print(data.toarray())\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "countvec()"
   ],
   "id": "30344794163a04d9",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['python' '不用' '人生漫长' '人生苦短' '喜欢']\n",
      "--------------------------------------------------\n",
      "<Compressed Sparse Row sparse matrix of dtype 'int64'\n",
      "\twith 6 stored elements and shape (2, 5)>\n",
      "  Coords\tValues\n",
      "  (0, 3)\t1\n",
      "  (0, 4)\t1\n",
      "  (0, 0)\t2\n",
      "  (1, 0)\t1\n",
      "  (1, 2)\t1\n",
      "  (1, 1)\t1\n",
      "--------------------------------------------------\n",
      "[[2 0 0 1 1]\n",
      " [1 1 1 0 0]]\n"
     ]
    }
   ],
   "execution_count": 3
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-09T11:58:10.066677Z",
     "start_time": "2025-01-09T11:58:10.058529Z"
    }
   },
   "cell_type": "code",
   "source": [
    "def cutword():\n",
    "    \"\"\"\n",
    "    通过jieba对中文进行分词\n",
    "    :return:\n",
    "    \"\"\"\n",
    "    con1 = jieba.cut(\"今天很残酷，明天更残酷，后天很美好，但绝对大部分是死在明天晚上，所以每个人不要放弃今天。\")\n",
    "\n",
    "    con2 = jieba.cut(\"我们看到的从很远星系来的光是在几百万年之前发出的，这样当我们看到宇宙时，我们是在看它的过去。\")\n",
    "\n",
    "    con3 = jieba.cut(\n",
    "        \"如果只用一种方式了解某样事物，你就不会真正了解它。了解事物真正含义的秘密取决于如何将其与我们所了解的事物相联系。\")\n",
    "\n",
    "    # 转换成列表\n",
    "    print(type(con1))\n",
    "    print('-' * 50)\n",
    "    # 把生成器转换成列表\n",
    "    content1 = list(con1)\n",
    "    content2 = list(con2)\n",
    "    content3 = list(con3)\n",
    "    print(content1)\n",
    "    print(content2)\n",
    "    print(content3)\n",
    "    # 把列表转换成字符串,每个词之间用空格隔开\n",
    "    print('-' * 50)\n",
    "    c1 = ' '.join(content1)\n",
    "    c2 = ' '.join(content2)\n",
    "    c3 = ' '.join(content3)\n",
    "\n",
    "    return c1, c2, c3\n",
    "\n",
    "\n",
    "def hanzivec():\n",
    "    \"\"\"\n",
    "    中文特征值化\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    c1, c2, c3 = cutword()  #jieba分词好的中文文本\n",
    "    print('-' * 50)\n",
    "    print(c1)\n",
    "    print(c2)\n",
    "    print(c3)\n",
    "    print('-' * 50)\n",
    "\n",
    "    cv = CountVectorizer()\n",
    "\n",
    "    data = cv.fit_transform([c1, c2, c3])\n",
    "\n",
    "    print(cv.get_feature_names_out())\n",
    "\n",
    "    print(data.toarray())\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "cutword()\n",
    "hanzivec()\n"
   ],
   "id": "fabac796c227fe57",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'generator'>\n",
      "--------------------------------------------------\n",
      "['今天', '很', '残酷', '，', '明天', '更', '残酷', '，', '后天', '很', '美好', '，', '但', '绝对', '大部分', '是', '死', '在', '明天', '晚上', '，', '所以', '每个', '人', '不要', '放弃', '今天', '。']\n",
      "['我们', '看到', '的', '从', '很', '远', '星系', '来', '的', '光是在', '几百万年', '之前', '发出', '的', '，', '这样', '当', '我们', '看到', '宇宙', '时', '，', '我们', '是', '在', '看', '它', '的', '过去', '。']\n",
      "['如果', '只用', '一种', '方式', '了解', '某样', '事物', '，', '你', '就', '不会', '真正', '了解', '它', '。', '了解', '事物', '真正', '含义', '的', '秘密', '取决于', '如何', '将', '其', '与', '我们', '所', '了解', '的', '事物', '相', '联系', '。']\n",
      "--------------------------------------------------\n",
      "<class 'generator'>\n",
      "--------------------------------------------------\n",
      "['今天', '很', '残酷', '，', '明天', '更', '残酷', '，', '后天', '很', '美好', '，', '但', '绝对', '大部分', '是', '死', '在', '明天', '晚上', '，', '所以', '每个', '人', '不要', '放弃', '今天', '。']\n",
      "['我们', '看到', '的', '从', '很', '远', '星系', '来', '的', '光是在', '几百万年', '之前', '发出', '的', '，', '这样', '当', '我们', '看到', '宇宙', '时', '，', '我们', '是', '在', '看', '它', '的', '过去', '。']\n",
      "['如果', '只用', '一种', '方式', '了解', '某样', '事物', '，', '你', '就', '不会', '真正', '了解', '它', '。', '了解', '事物', '真正', '含义', '的', '秘密', '取决于', '如何', '将', '其', '与', '我们', '所', '了解', '的', '事物', '相', '联系', '。']\n",
      "--------------------------------------------------\n",
      "--------------------------------------------------\n",
      "今天 很 残酷 ， 明天 更 残酷 ， 后天 很 美好 ， 但 绝对 大部分 是 死 在 明天 晚上 ， 所以 每个 人 不要 放弃 今天 。\n",
      "我们 看到 的 从 很 远 星系 来 的 光是在 几百万年 之前 发出 的 ， 这样 当 我们 看到 宇宙 时 ， 我们 是 在 看 它 的 过去 。\n",
      "如果 只用 一种 方式 了解 某样 事物 ， 你 就 不会 真正 了解 它 。 了解 事物 真正 含义 的 秘密 取决于 如何 将 其 与 我们 所 了解 的 事物 相 联系 。\n",
      "--------------------------------------------------\n",
      "['一种' '不会' '不要' '之前' '了解' '事物' '今天' '光是在' '几百万年' '发出' '取决于' '只用' '后天' '含义'\n",
      " '大部分' '如何' '如果' '宇宙' '我们' '所以' '放弃' '方式' '明天' '星系' '晚上' '某样' '残酷' '每个'\n",
      " '看到' '真正' '秘密' '绝对' '美好' '联系' '过去' '这样']\n",
      "[[0 0 1 0 0 0 2 0 0 0 0 0 1 0 1 0 0 0 0 1 1 0 2 0 1 0 2 1 0 0 0 1 1 0 0 0]\n",
      " [0 0 0 1 0 0 0 1 1 1 0 0 0 0 0 0 0 1 3 0 0 0 0 1 0 0 0 0 2 0 0 0 0 0 1 1]\n",
      " [1 1 0 0 4 3 0 0 0 0 1 1 0 1 0 1 1 0 1 0 0 1 0 0 0 1 0 0 0 2 1 0 0 1 0 0]]\n"
     ]
    }
   ],
   "execution_count": 9
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-09T11:58:14.483087Z",
     "start_time": "2025-01-09T11:58:14.478855Z"
    }
   },
   "cell_type": "code",
   "source": [
    "'''\n",
    "  tf 表示词频（某单词在某文本中的出现次数/该文本中所有词的词数），idf表示逆文本频率（语料库中包含某单词的文本数、的倒数、取log），tf-idf则表示词频 * 逆文档频率，tf-idf认为词的重要性随着它在文本中出现的次数成正比增加，但同时会随着它在整个语料库中出现的频率成反比下降。\n",
    "        对idf进行平滑、避免出现极大/极小值（smooth_idf=True）\n",
    "原文链接：https://blog.csdn.net/a7303349/article/details/126575663\n",
    "'''"
   ],
   "id": "b6f96d60a9483e20",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\n  tf 表示词频（某单词在某文本中的出现次数/该文本中所有词的词数），idf表示逆文本频率（语料库中包含某单词的文本数、的倒数、取log），tf-idf则表示词频 * 逆文档频率，tf-idf认为词的重要性随着它在文本中出现的次数成正比增加，但同时会随着它在整个语料库中出现的频率成反比下降。\\n        对idf进行平滑、避免出现极大/极小值（smooth_idf=True）\\n原文链接：https://blog.csdn.net/a7303349/article/details/126575663\\n'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 10
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": [
    "'''\n",
    "sklearn中提供的文本处理方法\n",
    "（1）CountVectorizer： 将文本文档集合转换为词频/字符频数矩阵，在单个类中实现了 tokenization （字符级+词级分词）、n-grams、剔除停用词、筛选高频词和 occurrence counting （频数统计）\n",
    "\n",
    "（2）TfidfTransformer：将词频/字符频数矩阵转换为标准化的 tf 或 tf-idf 矩阵，Tf 表示词频、而 tf-idf 表示词频乘以逆文档频率，常用于文本分类。\n",
    "\n",
    "（3）TfidfVectorizer：直接将原始文档集合转换为tf-idf 特征矩阵，将 CountVectorizer 和TfidfTransformer的所有功能组合在一个模型中。\n",
    "'''"
   ],
   "id": "77c63aba0d45d9ed"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-09T11:58:26.584326Z",
     "start_time": "2025-01-09T11:58:26.577840Z"
    }
   },
   "cell_type": "code",
   "source": [
    "def tfidfvec():\n",
    "    \"\"\"\n",
    "    中文特征值化,计算tfidf值\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    c1, c2, c3 = cutword()\n",
    "\n",
    "    print(c1, c2, c3)\n",
    "    # print(type([c1, c2, c3]))\n",
    "    tf = TfidfVectorizer(smooth_idf=True)\n",
    "\n",
    "    data = tf.fit_transform([c1, c2, c3])\n",
    "\n",
    "    print(tf.get_feature_names_out())\n",
    "    print('-'*50)\n",
    "    print(type(data))\n",
    "    print('-'*50)\n",
    "    print(data.toarray())\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "tfidfvec()"
   ],
   "id": "c7d56d781b56ab68",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'generator'>\n",
      "--------------------------------------------------\n",
      "['今天', '很', '残酷', '，', '明天', '更', '残酷', '，', '后天', '很', '美好', '，', '但', '绝对', '大部分', '是', '死', '在', '明天', '晚上', '，', '所以', '每个', '人', '不要', '放弃', '今天', '。']\n",
      "['我们', '看到', '的', '从', '很', '远', '星系', '来', '的', '光是在', '几百万年', '之前', '发出', '的', '，', '这样', '当', '我们', '看到', '宇宙', '时', '，', '我们', '是', '在', '看', '它', '的', '过去', '。']\n",
      "['如果', '只用', '一种', '方式', '了解', '某样', '事物', '，', '你', '就', '不会', '真正', '了解', '它', '。', '了解', '事物', '真正', '含义', '的', '秘密', '取决于', '如何', '将', '其', '与', '我们', '所', '了解', '的', '事物', '相', '联系', '。']\n",
      "--------------------------------------------------\n",
      "今天 很 残酷 ， 明天 更 残酷 ， 后天 很 美好 ， 但 绝对 大部分 是 死 在 明天 晚上 ， 所以 每个 人 不要 放弃 今天 。 我们 看到 的 从 很 远 星系 来 的 光是在 几百万年 之前 发出 的 ， 这样 当 我们 看到 宇宙 时 ， 我们 是 在 看 它 的 过去 。 如果 只用 一种 方式 了解 某样 事物 ， 你 就 不会 真正 了解 它 。 了解 事物 真正 含义 的 秘密 取决于 如何 将 其 与 我们 所 了解 的 事物 相 联系 。\n",
      "['一种' '不会' '不要' '之前' '了解' '事物' '今天' '光是在' '几百万年' '发出' '取决于' '只用' '后天' '含义'\n",
      " '大部分' '如何' '如果' '宇宙' '我们' '所以' '放弃' '方式' '明天' '星系' '晚上' '某样' '残酷' '每个'\n",
      " '看到' '真正' '秘密' '绝对' '美好' '联系' '过去' '这样']\n",
      "--------------------------------------------------\n",
      "<class 'scipy.sparse._csr.csr_matrix'>\n",
      "--------------------------------------------------\n",
      "[[0.         0.         0.21821789 0.         0.         0.\n",
      "  0.43643578 0.         0.         0.         0.         0.\n",
      "  0.21821789 0.         0.21821789 0.         0.         0.\n",
      "  0.         0.21821789 0.21821789 0.         0.43643578 0.\n",
      "  0.21821789 0.         0.43643578 0.21821789 0.         0.\n",
      "  0.         0.21821789 0.21821789 0.         0.         0.        ]\n",
      " [0.         0.         0.         0.2410822  0.         0.\n",
      "  0.         0.2410822  0.2410822  0.2410822  0.         0.\n",
      "  0.         0.         0.         0.         0.         0.2410822\n",
      "  0.55004769 0.         0.         0.         0.         0.2410822\n",
      "  0.         0.         0.         0.         0.48216441 0.\n",
      "  0.         0.         0.         0.         0.2410822  0.2410822 ]\n",
      " [0.15698297 0.15698297 0.         0.         0.62793188 0.47094891\n",
      "  0.         0.         0.         0.         0.15698297 0.15698297\n",
      "  0.         0.15698297 0.         0.15698297 0.15698297 0.\n",
      "  0.1193896  0.         0.         0.15698297 0.         0.\n",
      "  0.         0.15698297 0.         0.         0.         0.31396594\n",
      "  0.15698297 0.         0.         0.15698297 0.         0.        ]]\n"
     ]
    }
   ],
   "execution_count": 11
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-09T12:00:12.947840Z",
     "start_time": "2025-01-09T12:00:12.942494Z"
    }
   },
   "cell_type": "code",
   "source": [
    "def mm():\n",
    "    \"\"\"\n",
    "    归一化处理\n",
    "    :return: NOne\n",
    "    \"\"\"\n",
    "    # 归一化缺点 容易受极值的影响\n",
    "    #feature_range代表特征值范围，一般设置为(0,1),或者(-1,1),默认是(0,1)\n",
    "    mm = MinMaxScaler(feature_range=(0, 1))\n",
    "\n",
    "    data = mm.fit_transform([[90, 2, 10, 40], [60, 4, 15, 45], [75, 3, 13, 46]])\n",
    "\n",
    "    print(data)\n",
    "    print('-'*50)\n",
    "    out=mm.transform([[1, 2, 3, 4],[6, 5, 8, 7]])\n",
    "    print(out)\n",
    "    return None\n",
    "    #transform和fit_transform不同是，transform用于测试集，而且不会重新找最小值和最大值\n",
    "\n",
    "\n",
    "mm()"
   ],
   "id": "6e20a8b55e32be34",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.         0.         0.         0.        ]\n",
      " [0.         1.         1.         0.83333333]\n",
      " [0.5        0.5        0.6        1.        ]]\n",
      "--------------------------------------------------\n",
      "[[-1.96666667  0.         -1.4        -6.        ]\n",
      " [-1.8         1.5        -0.4        -5.5       ]]\n"
     ]
    }
   ],
   "execution_count": 14
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-09T12:03:23.237287Z",
     "start_time": "2025-01-09T12:03:23.233733Z"
    }
   },
   "cell_type": "code",
   "source": "(1-60)/30",
   "id": "3fdd3b16e18b39c5",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1.9666666666666666"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 25
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": [
    "'''\n",
    "归一化后加快了梯度下降求最优解的速度；\n",
    "如果机器学习模型使用梯度下降法求最优解时，归一化往往非常有必要，否则很难收敛甚至不能收敛。\n",
    "归一化有可能提高精度；\n",
    "一些分类器需要计算样本之间的距离（如欧氏距离），例如KNN。如果一个特征值域范围非常大，那么距离计算就主要取决于这个特征，从而与实际情况相悖（比如这时实际情况是值域范围小的特征更重要）\n",
    "'''"
   ],
   "id": "58cf4281a86a409a"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-09T12:00:41.502271Z",
     "start_time": "2025-01-09T12:00:41.497487Z"
    }
   },
   "cell_type": "code",
   "source": [
    "def stand():\n",
    "    \"\"\"\n",
    "    标准化缩放，不是标准正太分布，只均值为0，方差为1的分布\n",
    "    :return:\n",
    "    \"\"\"\n",
    "    std = StandardScaler()\n",
    "\n",
    "    data = std.fit_transform([[1., -1., 3.], [2., 4., 2.], [4., 6., -1.]])\n",
    "\n",
    "    print(data)\n",
    "    print('-' * 50)\n",
    "    print(std.mean_)\n",
    "    print('-' * 50)\n",
    "    print(std.var_)\n",
    "    print(std.n_samples_seen_)  # 样本数\n",
    "    return data\n",
    "\n",
    "\n",
    "data=stand()"
   ],
   "id": "649d528d4b022841",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-1.06904497 -1.35873244  0.98058068]\n",
      " [-0.26726124  0.33968311  0.39223227]\n",
      " [ 1.33630621  1.01904933 -1.37281295]]\n",
      "--------------------------------------------------\n",
      "[2.33333333 3.         1.33333333]\n",
      "--------------------------------------------------\n",
      "[1.55555556 8.66666667 2.88888889]\n",
      "3\n"
     ]
    }
   ],
   "execution_count": 16
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-09T12:00:49.100281Z",
     "start_time": "2025-01-09T12:00:49.096648Z"
    }
   },
   "cell_type": "code",
   "source": "type(data)",
   "id": "3faa93f2913af552",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 17
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-09T12:00:57.004574Z",
     "start_time": "2025-01-09T12:00:57.000084Z"
    }
   },
   "cell_type": "code",
   "source": [
    "std1 = StandardScaler()\n",
    "#为了证明上面输出的结果的均值是为0的，方差为1\n",
    "data1 = std1.fit_transform(data)\n",
    "# print(data1)  #这个并不是我们想看的，没意义\n",
    "# 均值\n",
    "print(std1.mean_)\n",
    "# 方差\n",
    "print(std1.var_)"
   ],
   "id": "5c0b2739be990ea6",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-1.48029737e-16  7.40148683e-17  7.40148683e-17]\n",
      "[1. 1. 1.]\n"
     ]
    }
   ],
   "execution_count": 18
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-09T12:01:15.997082Z",
     "start_time": "2025-01-09T12:01:15.992382Z"
    }
   },
   "cell_type": "code",
   "source": "(np.square(1-2.333)+np.square(2-2.333)+np.square(4-2.333))/3",
   "id": "9d8b02ebecb7ec59",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "np.float64(1.5555556666666668)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 19
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-09T12:01:19.821325Z",
     "start_time": "2025-01-09T12:01:19.816986Z"
    }
   },
   "cell_type": "code",
   "source": "(1-2.333)/np.sqrt(1.55555)",
   "id": "f79775e87862303c",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "np.float64(-1.068779614944516)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 20
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## 缺失值处理",
   "id": "65b484a10b58f2e0"
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": [
    "'''\n",
    "SimpleImputer是一个用于处理缺失值的工具，它提供了一种简单的方法来填补数据集中的缺失值。在机器学习中，处理缺失值是数据预处理的重要步骤，因为许多算法无法处理含有缺失值的数据。\n",
    "'''"
   ],
   "id": "3d7ec462d9fbbcf"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-09T12:01:51.179395Z",
     "start_time": "2025-01-09T12:01:51.173180Z"
    }
   },
   "cell_type": "code",
   "source": [
    "def im():\n",
    "    \"\"\"\n",
    "    缺失值处理\n",
    "    :return:NOne\n",
    "    \"\"\"\n",
    "    # NaN, nan,缺失值必须是这种形式，如果是？号(或者其他符号)，就要replace换成这种\n",
    "    im = SimpleImputer(missing_values=np.nan, strategy='mean')\n",
    "\n",
    "    data = im.fit_transform([[1, 2], [np.nan, 3], [7, 6], [3, 2]])\n",
    "\n",
    "    print(data)\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "im()"
   ],
   "id": "82ed7c1bdb3f8a2e",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.         2.        ]\n",
      " [3.66666667 3.        ]\n",
      " [7.         6.        ]\n",
      " [3.         2.        ]]\n"
     ]
    }
   ],
   "execution_count": 22
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-09T12:01:59.724603Z",
     "start_time": "2025-01-09T12:01:59.721261Z"
    }
   },
   "cell_type": "code",
   "source": "11/3",
   "id": "156fc458286d9bd2",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.6666666666666665"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 23
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-09T12:02:03.121005Z",
     "start_time": "2025-01-09T12:02:03.117032Z"
    }
   },
   "cell_type": "code",
   "source": "np.nan+10",
   "id": "4858668602c44bda",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "nan"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 24
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": [
    "'''\n",
    "varianceThreshold是sklearn库中feature_selection类中的一个函数，其特征选择原理只关心特征变量X，而不需要数据中的输出结果y，因此可以被用于无监督学习,可结合matplotlib库进行可视化。\n",
    "'''"
   ],
   "id": "d107efb35342333d"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-09T12:06:11.199718Z",
     "start_time": "2025-01-09T12:06:11.194771Z"
    }
   },
   "cell_type": "code",
   "source": [
    "def var():\n",
    "    \"\"\"\n",
    "    特征选择-删除低方差的特征\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    #默认只删除方差为0,threshold是方差阈值，删除比这个值小的那些特征\n",
    "    var = VarianceThreshold(threshold=0.1) # 保留方差大于0.1的特征\n",
    "\n",
    "    data = var.fit_transform([[0, 2, 0, 3],\n",
    "                              [0, 1, 4, 3],\n",
    "                              [0, 1, 1, 3]])\n",
    "\n",
    "    print(data)\n",
    "    # 获得剩余的特征的列编号\n",
    "    print('The surport is %s' % var.get_support(True))\n",
    "    return None\n",
    "\n",
    "\n",
    "var()"
   ],
   "id": "51ed332fdefeeeaf",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2 0]\n",
      " [1 4]\n",
      " [1 1]]\n",
      "The surport is [1 2]\n"
     ]
    }
   ],
   "execution_count": 26
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": [
    "\"\"\"\n",
    "主成分分析（Principal Component Analysis, PCA）是一种常用的无监督降维算法，主要用于数据的特征提取和维度压缩。其目标是将高维数据映射到低维空间，同时尽可能保留数据的主要信息。\n",
    "PCA的主要思想\n",
    "寻找新的坐标轴（主成分），使数据在这些轴上的方差最大。\n",
    "这些新坐标轴是数据的线性组合，并且彼此正交（无相关性）。\n",
    "降维通过选择前 k 个方差最大的主成分实现。\n",
    "\"\"\""
   ],
   "id": "9f9a296a3a1ca6ae"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-09T12:07:13.426551Z",
     "start_time": "2025-01-09T12:07:13.420754Z"
    }
   },
   "cell_type": "code",
   "source": [
    "def pca():\n",
    "    \"\"\"\n",
    "    主成分分析进行特征降维\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    # n_ components:小数 0~1 90% 业界选择 90~95%\n",
    "\n",
    "    # 当n_components的值为0到1之间的浮点数时，表示我们希望保留的主成分解释的方差比例。方差比例是指 得到输出的每一列的方差值和除以原有数据方差之和。\n",
    "    # 具体而言，n_components=0.9表示我们希望选择足够的主成分，以使它们解释数据方差的90%。\n",
    "\n",
    "    # n_components如果是整数   减少到的特征数量\n",
    "    # 原始数据方差\n",
    "    original_value = np.array([[2, 8, 4, 5], [6, 3, 0, 8], [5, 4, 9, 1]])\n",
    "    print(np.var(original_value, axis=0).sum()) #最初数据的方差\n",
    "    print('-'* 50)\n",
    "    pca = PCA(n_components=0.9)\n",
    "\n",
    "    data = pca.fit_transform(original_value)\n",
    "\n",
    "    print(data)\n",
    "    print(type(data))\n",
    "    #计算data的方差\n",
    "    print(np.var(data, axis=0).sum())\n",
    "    print('-'*50)\n",
    "    print(pca.explained_variance_ratio_)\n",
    "    # 计算data的方差占总方差的比例\n",
    "    print(pca.explained_variance_ratio_.sum())\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "pca()"
   ],
   "id": "c42b1e9d974ae487",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "29.333333333333336\n",
      "--------------------------------------------------\n",
      "[[-3.13587302e-16  3.82970843e+00]\n",
      " [-5.74456265e+00 -1.91485422e+00]\n",
      " [ 5.74456265e+00 -1.91485422e+00]]\n",
      "<class 'numpy.ndarray'>\n",
      "29.333333333333346\n",
      "--------------------------------------------------\n",
      "[0.75 0.25]\n",
      "1.0\n"
     ]
    }
   ],
   "execution_count": 27
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-09T12:07:19.829436Z",
     "start_time": "2025-01-09T12:07:19.825496Z"
    }
   },
   "cell_type": "code",
   "source": "22/29.333333333333336",
   "id": "2f0bef2653f4b741",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7499999999999999"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 28
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-09T12:08:08.192771Z",
     "start_time": "2025-01-09T12:08:08.111844Z"
    }
   },
   "cell_type": "code",
   "source": [
    "from matplotlib import pyplot as plt\n",
    "x = np.random.rand(10000) #每个的概率\n",
    "t = np.arange(len(x)) # 0~9999\n",
    "plt.plot(t,x,'g.',label=\"Uniform Distribution\") # 画出原始数据\n",
    "plt.legend(loc=\"upper left\") # 显示图例\n",
    "plt.grid()# 显示网格\n",
    "plt.show()# 显示图像"
   ],
   "id": "23661c659d325091",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 37
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
